package menagementBean;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import javax.annotation.security.RolesAllowed;
import javax.ejb.Stateless;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.Query;

import menagement.dto.EscursioneDTO;
import menagement.dto.EscursionePrenotazioneDTO;
import menagement.dto.EscursioniPacchettoDTO;
import menagement.dto.HotelDTO;
import menagement.dto.HotelPacchettoDTO;
import menagement.dto.HotelPrenotazioneDTO;
import menagement.dto.PrenotazioneDTO;
import menagement.PacketMgr;
import menagement.dto.PacketDTO;
import menagement.dto.VoloDTO;
import entities.Escursione;
import entities.Escursione_In_Pacchetto;
import entities.Escursione_Prenotazione;
import entities.Group;
import entities.Hotel;
import entities.Hotel_In_Pacchetto;
import entities.Hotel_Prenotazione;
import entities.Impiegato_Modifica;
import entities.Pacchetto;
import entities.Prenotazione;
import entities.Volo;

@Stateless
public class PacketMgrBean implements PacketMgr {
	
	@PersistenceContext
    private EntityManager em;
	
	@Override
	@RolesAllowed({Group._ADMIN})
	public void savePacchetto(PacketDTO packet, HotelPacchettoDTO hpdto, EscursioniPacchettoDTO edto){
		Pacchetto newPackage= new Pacchetto(packet);
		newPackage.setValido(true);
		em.persist(newPackage);
		if(hpdto.getIdHotel()!=0){
			hpdto.setIdPacchetto(newPackage.getIdPacchetto());
			Hotel_In_Pacchetto hotelPacchetto= new Hotel_In_Pacchetto(hpdto);
			em.persist(hotelPacchetto);
		}
		if(edto.getIdEscursione()!=0){
			edto.setIdPacchetto(newPackage.getIdPacchetto());
			Escursione_In_Pacchetto escursionePacchetto= new Escursione_In_Pacchetto(edto);
			em.persist(escursionePacchetto);
		}
	}
	
	@Override
	@RolesAllowed({Group._ADMIN})
	public void update(PacketDTO packet, String mail) {
	    Pacchetto pkt = em.find(Pacchetto.class, packet.getIdPacchetto());
	    if(pkt==null){
	        throw new IllegalArgumentException("NON ESISTE IN DB UN PACCHETTO CON IL CODICE DELLA MODIFICA");
	    }
	    pkt.setDescrizione(packet.getDescrizione());
	    pkt.setNome(packet.getNome());
	    pkt.setEmail(packet.getEmail());
	    pkt.setPrezzo(packet.getPrezzo());
	    pkt.setVolo_Codice(packet.getCodiceVolo());
	    
	    //Tengo traccia di chi ha modificato
	    Impiegato_Modifica imp= new Impiegato_Modifica();
	    imp.setPacchetto_IdPacchetto(pkt.getIdPacchetto());
	    imp.setEmail(mail);
	    Date data= new Date();
	    imp.setData(data);
	    em.persist(imp);
	}
	
	@Override
	@RolesAllowed({Group._ADMIN})
	public void updateProdottiPacchetto(String mail, PacketDTO selezionato, ArrayList<HotelDTO> hotelDaEliminare, List<HotelDTO> hotelDaAggiungere,
			   ArrayList<EscursioneDTO> escursioniDaEliminare, List<EscursioneDTO> escursioniDaAggiungere)
	{
		Pacchetto pkt = em.find(Pacchetto.class, selezionato.getIdPacchetto());
	    if(pkt==null){
	        throw new IllegalArgumentException("NON ESISTE IN DB UN PACCHETTO CON IL CODICE DELLA MODIFICA");
	    }
	    pkt.setVolo_Codice(selezionato.getCodiceVolo());
	    pkt.setPrezzo(selezionato.getPrezzo());
		
	    //per ogni hotel da eliminare, trovo le corrispondenti righe nella tabella ponte (per errore potrebbero essere + di una) e le cancello
	    for(int i=0; i<hotelDaEliminare.size();i++){
			Query k=em.createNamedQuery("Hotel.IdHotelPacchetto").setParameter("pacc", selezionato.getIdPacchetto()).setParameter("hotel", hotelDaEliminare.get(i).getCodice());
	    	List<Hotel_In_Pacchetto> listaEliminare= (List<Hotel_In_Pacchetto>) k.getResultList();
	    	for(int j=0; j<listaEliminare.size();j++){
		    	Hotel_In_Pacchetto hip= em.find(Hotel_In_Pacchetto.class, listaEliminare.get(j).getID_Hotel_Pacchetto());
		    	if(hip==null){
			        throw new IllegalArgumentException("NON ESISTE IN DB UN PACCHETTO CON IL CODICE DELLA MODIFICA");
			    }
		    	em.remove(hip);
		    	System.out.println("Qua dovrebbe aver rimosso un pacchetto dalla ponte.");
	    	}
	    }
	    //per ogni hotel da aggiungere creo una istanza della ponte e la aggiungo in DB
	    for(int j=0; j<hotelDaAggiungere.size();j++){
	    	Hotel_In_Pacchetto hotel= new Hotel_In_Pacchetto();
	    	hotel.setHotel_Codice(hotelDaAggiungere.get(j).getCodice());
	    	hotel.setPacchetto_idPacchetto(selezionato.getIdPacchetto());
	    	em.persist(hotel);
    	}
	    
	    //per ogni escursione da eliminare, trovo le corrispondenti righe nella tabella ponte (per errore potrebbero essere + di una) e le cancello
	    for(int i=0; i<escursioniDaEliminare.size();i++){
			Query k=em.createNamedQuery("Escursione.IdEscursionePacchetto").setParameter("pacc", selezionato.getIdPacchetto()).setParameter("escurs", escursioniDaEliminare.get(i).getCodice());
	    	List<Escursione_In_Pacchetto> listaEliminare= (List<Escursione_In_Pacchetto>) k.getResultList();
	    	for(int j=0; j<listaEliminare.size();j++){
		    	Escursione_In_Pacchetto eip= em.find(Escursione_In_Pacchetto.class, listaEliminare.get(j).getID_Escursione_Pacchetto());
		    	if(eip==null){
			        throw new IllegalArgumentException("NON ESISTE IN DB UNA ESCURSIONE CON IL CODICE DELLA MODIFICA");
			    }
		    	em.remove(eip);
		    	System.out.println("Qua dovrebbe aver rimosso una escursione dalla ponte.");
	    	}
	    }
	    
	    //per ogni escursione da aggiungere creo una istanza della ponte e la aggiungo in DB
	    for(int j=0; j<escursioniDaAggiungere.size();j++){
	    	Escursione_In_Pacchetto escursione= new Escursione_In_Pacchetto();
	    	escursione.setEscursione_Codice(escursioniDaAggiungere.get(j).getCodice());
	    	escursione.setPacchetto_IdPacchetto(selezionato.getIdPacchetto());
	    	em.persist(escursione);
    	}
	    
	    Impiegato_Modifica imp= new Impiegato_Modifica();
	    imp.setPacchetto_IdPacchetto(pkt.getIdPacchetto());
	    imp.setEmail(mail);
	    Date data= new Date();
	    imp.setData(data);
	    em.persist(imp);
	}
	
	@Override
	public void deletePacchetto(PacketDTO packet){
		System.out.println("Sono arrivato all'inizio -.-");
		Pacchetto pkt = em.find(Pacchetto.class, packet.getIdPacchetto());
	    if(pkt==null){
	        throw new IllegalArgumentException("NON ESISTE IN DB UN PACCHETTO CON IL CODICE DELLA MODIFICA");
	    }
	    System.out.println("Sono arrivato!!!");
	    pkt.setValido(false);
	}
	
	@Override
	public ArrayList<VoloDTO> ListaCitta(){
		Query q= em.createNamedQuery("Volo.findAll");
		List<Volo> listaVolo =  (List<Volo>) q.getResultList();
		ArrayList<VoloDTO> listaVoloDTO = new ArrayList<VoloDTO>();
		System.out.println("Lista voli creata, elementi: "+listaVolo.size());
		for (int i=0; i<listaVolo.size(); i++)
		{
			if(i==0){

				VoloDTO lista = new VoloDTO();
				lista.setAeroportoPartenza(listaVolo.get(i).getAeroportoPartenza());
				lista.setAeroportoArrivo(listaVolo.get(i).getAeroportoArrivo());
				lista.setData(listaVolo.get(i).getData());
				lista.setDurata(listaVolo.get(i).getDurata());
				lista.setPosti_Disponibili(listaVolo.get(i).getPosti_Disponibili());
				lista.setPrezzo(listaVolo.get(i).getPrezzo());
				lista.setCittaPartenza(listaVolo.get(i).getCittaPartenza());
				lista.setCittaArrivo(listaVolo.get(i).getCittaArrivo());
				lista.setCodice(listaVolo.get(i).getCodice());
				lista.setValido(listaVolo.get(i).isValido());
				lista.setDataRitorno(listaVolo.get(i).getDataRitorno());
	
				listaVoloDTO.add(lista);
			}
			else if(!(listaVolo.get(i).getCittaArrivo().equals(listaVolo.get(i-1).getCittaArrivo()))){

				System.out.println(listaVolo.get(i).getCodice());
				System.out.println(listaVolo.get(i).getAeroportoArrivo());
				VoloDTO lista = new VoloDTO();
				lista.setAeroportoPartenza(listaVolo.get(i).getAeroportoPartenza());
				lista.setAeroportoArrivo(listaVolo.get(i).getAeroportoArrivo());
				lista.setData(listaVolo.get(i).getData());
				lista.setDurata(listaVolo.get(i).getDurata());
				lista.setPosti_Disponibili(listaVolo.get(i).getPosti_Disponibili());
				lista.setPrezzo(listaVolo.get(i).getPrezzo());
				lista.setCittaPartenza(listaVolo.get(i).getCittaPartenza());
				lista.setCittaArrivo(listaVolo.get(i).getCittaArrivo());
				lista.setCodice(listaVolo.get(i).getCodice());
				lista.setValido(listaVolo.get(i).isValido());
				lista.setDataRitorno(listaVolo.get(i).getDataRitorno());
	
				listaVoloDTO.add(lista);
			}
		}
		return listaVoloDTO;
	}
	
	@Override
	public ArrayList<PacketDTO> ListaPacchetti(){
		Query q= em.createNamedQuery("Pacchetto.findAll");
		List<Pacchetto> listaPacchetti =  (List<Pacchetto>) q.getResultList();
		ArrayList<PacketDTO> listaPacchettiDTO = new ArrayList<PacketDTO>();
		
		for(int i=0; i<listaPacchetti.size(); i++){
			
			PacketDTO pkt= new PacketDTO();
			pkt.setIdPacchetto(listaPacchetti.get(i).getIdPacchetto());
			pkt.setDescrizione(listaPacchetti.get(i).getDescrizione());
			pkt.setEmail(listaPacchetti.get(i).getEmail());
			pkt.setNome(listaPacchetti.get(i).getNome());
			pkt.setPrezzo(listaPacchetti.get(i).getPrezzo());
			pkt.setCodiceVolo(listaPacchetti.get(i).getVolo_Codice());
			
			listaPacchettiDTO.add(pkt);
		}
		
		
		
		return listaPacchettiDTO;
	}
	
	@Override
	public ArrayList<EscursioniPacchettoDTO> ListaEscursioniPacchetto(int codice){
		
		Query q=em.createNamedQuery("Escursione.trovaEscursioneInpacchetto").setParameter("codice", codice);
		List<Escursione_In_Pacchetto> listaEscursioni =  (List<Escursione_In_Pacchetto>) q.getResultList();
		ArrayList<EscursioniPacchettoDTO> listaEPDTO= new ArrayList<EscursioniPacchettoDTO>();
		
		for(int i=0; i<listaEscursioni.size();i++){
			EscursioniPacchettoDTO esc= new EscursioniPacchettoDTO();
			
			esc.setID_Escursione_Pacchetto(listaEscursioni.get(i).getID_Escursione_Pacchetto());
			esc.setIdEscursione(listaEscursioni.get(i).getEscursione_Codice());
			esc.setIdPacchetto(listaEscursioni.get(i).getPacchetto_IdPacchetto());
			
			listaEPDTO.add(esc);
		}
		
		
		
		return listaEPDTO;
	}

	@Override
	public ArrayList<HotelPacchettoDTO> ListaHotelPacchetto(int codice){
		
		Query q=em.createNamedQuery("Hotel.trovaHotelInpacchetto").setParameter("codice", codice);
		List<Hotel_In_Pacchetto> listaHotel =  (List<Hotel_In_Pacchetto>) q.getResultList();
		ArrayList<HotelPacchettoDTO> listaHPDTO= new ArrayList<HotelPacchettoDTO>();
		
		for(int i=0; i<listaHotel.size();i++){
			HotelPacchettoDTO hotel= new HotelPacchettoDTO();
			
			hotel.setID_Hotel_Pacchetto(listaHotel.get(i).getID_Hotel_Pacchetto());
			hotel.setIdHotel(listaHotel.get(i).getHotel_Codice());
			hotel.setIdPacchetto(listaHotel.get(i).getPacchetto_idPacchetto());
			
			listaHPDTO.add(hotel);
		}
		
		
		
		return listaHPDTO;
	}
	
	@Override
	public ArrayList<VoloDTO> ListaVoliCitta(int codice){
		Query q=em.createNamedQuery("Volo.findCittaVoliPerCodice").setParameter("codice", codice);
		List<Volo> listaVoli =  (List<Volo>) q.getResultList();
		ArrayList<VoloDTO> listaVoliDTO= new ArrayList<VoloDTO>();
		if(!listaVoli.isEmpty()){
			Query k=em.createNamedQuery("Volo.findVoliPerCitta").setParameter("citta", listaVoli.get(0).getCittaArrivo());
			List<Volo> lista =  (List<Volo>) k.getResultList();
			for(int i=0; i<lista.size();i++){
				VoloDTO listaFinale = new VoloDTO();
				listaFinale.setAeroportoPartenza(lista.get(i).getAeroportoPartenza());
				listaFinale.setAeroportoArrivo(lista.get(i).getAeroportoArrivo());
				listaFinale.setData(lista.get(i).getData());
				listaFinale.setDurata(lista.get(i).getDurata());
				listaFinale.setPosti_Disponibili(lista.get(i).getPosti_Disponibili());
				listaFinale.setPrezzo(lista.get(i).getPrezzo());
				listaFinale.setCittaPartenza(lista.get(i).getCittaPartenza());
				listaFinale.setCittaArrivo(lista.get(i).getCittaArrivo());
				listaFinale.setCodice(lista.get(i).getCodice());
				listaFinale.setValido(lista.get(i).isValido());
				listaFinale.setDataRitorno(lista.get(i).getDataRitorno());
				
				listaVoliDTO.add(listaFinale);
			}
			
		}
		else
			System.out.println("Per qualche motivo nonostante abbia un codice di volo in input, non risultano voli con quel codice in DB.");
			
			
		
		return listaVoliDTO;
	}
	
	@Override
	public ArrayList<HotelDTO> listaHotelCitta(int codice){
		Query q=em.createNamedQuery("Volo.findCittaVoliPerCodice").setParameter("codice", codice);
		List<Volo> listaVoli =  (List<Volo>) q.getResultList();
		ArrayList<HotelDTO> listaHotelDTO= new ArrayList<HotelDTO>();
		if(!listaVoli.isEmpty()){
			Query k=em.createNamedQuery("Hotel.trovaHotelInCitta").setParameter("citta", listaVoli.get(0).getCittaArrivo());
			List<Hotel> ListaHotel =  (List<Hotel>) k.getResultList();
			for(int i=0; i<ListaHotel.size();i++){
				
				HotelDTO hotel = new HotelDTO();
				hotel.setNome(ListaHotel.get(i).getNome());
				hotel.setCodice(ListaHotel.get(i).getCodice());
				hotel.setIndirizzo(ListaHotel.get(i).getIndirizzo());
				hotel.setMail(ListaHotel.get(i).getMail());
				hotel.setN_Stelle(ListaHotel.get(i).getN_Stelle());
				hotel.setPrezzo(ListaHotel.get(i).getPrezzo());
				hotel.setStanze_Disponibili(ListaHotel.get(i).getStanze_Disponibili());
				hotel.setTelefono(ListaHotel.get(i).getTelefono());
				hotel.setCitta(ListaHotel.get(i).getCitta());

				listaHotelDTO.add(hotel);
			}
		}
		else
			System.out.println("Per qualche motivo nonostante abbia un codice di volo in input, non risultano voli con quel codice in DB.");
		
		return listaHotelDTO;
	}
	
	@Override
	public ArrayList<EscursioneDTO> listaEscursioniCitta(int codice){
		Query q=em.createNamedQuery("Volo.findCittaVoliPerCodice").setParameter("codice", codice);
		List<Volo> listaVoli =  (List<Volo>) q.getResultList();
		ArrayList<EscursioneDTO> listaEscursioniDTO= new ArrayList<EscursioneDTO>();
		if(!listaVoli.isEmpty()){
			Query k=em.createNamedQuery("Escursione.trovaEscursioniInCitta").setParameter("citta", listaVoli.get(0).getCittaArrivo());
			List<Escursione> ListaEscursioni =  (List<Escursione>) k.getResultList();
			for(int i=0; i<ListaEscursioni.size();i++){
				
				EscursioneDTO escursione=new EscursioneDTO();
				escursione.setNome(ListaEscursioni.get(i).getNome());
				escursione.setCodice(ListaEscursioni.get(i).getCodice());
				escursione.setDurata(ListaEscursioni.get(i).getDurata());
				escursione.setLuogoPartenza(ListaEscursioni.get(i).getLuogoPartenza());
				escursione.setPrezzo(ListaEscursioni.get(i).getPrezzo());
				escursione.setStagione(ListaEscursioni.get(i).getStagione());
				escursione.setTipologia(ListaEscursioni.get(i).getTipologia());

				listaEscursioniDTO.add(escursione);
			}
		}
		else
			System.out.println("Per qualche motivo nonostante abbia un codice di volo in input, non risultano voli con quel codice in DB.");
		
		return listaEscursioniDTO;
	}
	
	@Override
	public HotelDTO getHotel(int codice){
		Query q=em.createNamedQuery("Hotel.trovaHotelPerCodice").setParameter("codice", codice);
		List<Hotel> ListaHotel =  (List<Hotel>) q.getResultList();
		HotelDTO hotel= new HotelDTO();
		if(!ListaHotel.isEmpty()){
			hotel.setNome(ListaHotel.get(0).getNome());
			hotel.setCodice(ListaHotel.get(0).getCodice());
			hotel.setIndirizzo(ListaHotel.get(0).getIndirizzo());
			hotel.setMail(ListaHotel.get(0).getMail());
			hotel.setN_Stelle(ListaHotel.get(0).getN_Stelle());
			hotel.setPrezzo(ListaHotel.get(0).getPrezzo());
			hotel.setStanze_Disponibili(ListaHotel.get(0).getStanze_Disponibili());
			hotel.setTelefono(ListaHotel.get(0).getTelefono());
			hotel.setCitta(ListaHotel.get(0).getCitta());
		}
		
		else
			System.out.println("Sono nel metodo getHotel(codice hotel) in PacketMgrBean, e non risultano hotel in DB col codice passato, cosa tecnicamente impossibile");
			
		
		return hotel;
	}
	
	@Override
	public EscursioneDTO getEscursione (int codice){
		
		Query q=em.createNamedQuery("Escursione.trovaEscursioniPerCodice").setParameter("codice", codice);
		List<Escursione> ListaEscursioni = (List<Escursione>) q.getResultList();
		EscursioneDTO escursione= new EscursioneDTO();
		if(!ListaEscursioni.isEmpty()){
			escursione.setNome(ListaEscursioni.get(0).getNome());
			escursione.setCodice(ListaEscursioni.get(0).getCodice());
			escursione.setDurata(ListaEscursioni.get(0).getDurata());
			escursione.setLuogoPartenza(ListaEscursioni.get(0).getLuogoPartenza());
			escursione.setPrezzo(ListaEscursioni.get(0).getPrezzo());
			escursione.setStagione(ListaEscursioni.get(0).getStagione());
			escursione.setTipologia(ListaEscursioni.get(0).getTipologia());
		}
		else
			System.out.println("Sono nel metodo getescursione(codice escursione) in PacketMgrBean, e non risultano escursioni in DB col codice passato, cosa tecnicamente impossibile");
		
		
		return escursione;
	}
	
	@Override
	public ArrayList <VoloDTO> trovaVoli(){
		Query q=em.createNamedQuery("Volo.findAll");
		List<Volo> listaVoli =  (List<Volo>) q.getResultList();
		ArrayList<VoloDTO> listaV= new ArrayList<VoloDTO>();
		
		for(int i=0; i<listaVoli.size();i++){
			VoloDTO volo= new VoloDTO();
			
			volo.setAeroportoPartenza(listaVoli.get(i).getAeroportoPartenza());
			volo.setAeroportoArrivo(listaVoli.get(i).getAeroportoArrivo());
			volo.setData(listaVoli.get(i).getData());
			volo.setDurata(listaVoli.get(i).getDurata());
			volo.setPosti_Disponibili(listaVoli.get(i).getPosti_Disponibili());
			volo.setPrezzo(listaVoli.get(i).getPrezzo());
			volo.setCittaPartenza(listaVoli.get(i).getCittaPartenza());
			volo.setCittaArrivo(listaVoli.get(i).getCittaArrivo());
			volo.setCodice(listaVoli.get(i).getCodice());
			volo.setValido(listaVoli.get(i).isValido());
			volo.setDataRitorno(listaVoli.get(i).getDataRitorno());
			
			listaV.add(volo);
		}
		
		return listaV;
	}
	
	@Override
	public VoloDTO getVolo(int codice){
		System.out.println("Punto 1.1");
		Query q=em.createNamedQuery("Volo.findTuttiVoliPerCodice").setParameter("codice", codice);
		List<Volo> ListaVolo =  (List<Volo>) q.getResultList();
		VoloDTO volo= new VoloDTO();
		if(!ListaVolo.isEmpty()){
			volo.setAeroportoPartenza(ListaVolo.get(0).getAeroportoPartenza());
			volo.setAeroportoArrivo(ListaVolo.get(0).getAeroportoArrivo());
			volo.setData(ListaVolo.get(0).getData());
			volo.setDurata(ListaVolo.get(0).getDurata());
			volo.setPosti_Disponibili(ListaVolo.get(0).getPosti_Disponibili());
			volo.setPrezzo(ListaVolo.get(0).getPrezzo());
			volo.setCittaPartenza(ListaVolo.get(0).getCittaPartenza());
			volo.setCittaArrivo(ListaVolo.get(0).getCittaArrivo());
			volo.setCodice(ListaVolo.get(0).getCodice());
			volo.setValido(ListaVolo.get(0).isValido());
			volo.setDataRitorno(ListaVolo.get(0).getDataRitorno());
		}
		
		else
			System.out.println("Sono nel metodo getVolo(codice volo) in PacketMgrBean, e non risultano voli in DB col codice passato, cosa tecnicamente impossibile");
		
		
		return volo;
	}
	
	public int persistPrenotazione(PrenotazioneDTO pren){
		Prenotazione newPren= new Prenotazione(pren);
		em.persist(newPren);
		System.out.println("Qua dovrebbe aver fatto il persist della prenotazione");
		Volo volo=em.find(Volo.class,pren.getCodiceVolo());
		volo.setPosti_Disponibili(volo.getPosti_Disponibili()-pren.getN_Persone());
		return newPren.getIdPrenotazione();
	}
	public void persistHotel(HotelDTO hotel, int idPren, int persone){
		System.out.println("Entro nel persist hotel");
		
		//aggiorno numero stanze dell'hotel
		Hotel ht=em.find(Hotel.class, hotel.getCodice());
		ht.setStanze_Disponibili(ht.getStanze_Disponibili()-persone);
		
		HotelPrenotazioneDTO hpdto= new HotelPrenotazioneDTO();
		hpdto.setIdHotel(hotel.getCodice());
		System.out.println("Id prenotazione: "+idPren);
		hpdto.setIdPrenotazione(idPren);
		Hotel_Prenotazione hp= new Hotel_Prenotazione(hpdto);
		System.out.println("Codice Hotel: "+hp.getHotel_Codice());
		em.persist(hp);
		System.out.println("Qua ha persistato un hotel");
	}
	
	public void persistEscursione(EscursioneDTO esc, int idPren){
		System.out.println("Entro nell'if delle escursione");
		EscursionePrenotazioneDTO epdto= new EscursionePrenotazioneDTO();
		epdto.setIdEscursione(esc.getCodice());
		System.out.println("Id prenotazione: "+idPren);
		epdto.setIdPrenotazione(idPren);
		Escursione_Prenotazione ep= new Escursione_Prenotazione(epdto);
		System.out.println("Codice Escursione: "+ep.getEscursione_Codice());
		em.persist(ep);
		System.out.println("Qua ha persistato una escursione");

	}
	
	public ArrayList<PrenotazioneDTO> travaPrenotazioni(String mail){
		Query q=em.createNamedQuery("Prenotazione.findPrenotazioniUtente").setParameter("mail", mail);
		List<Prenotazione> listaPrenotazioni =  (List<Prenotazione>) q.getResultList();
		ArrayList<PrenotazioneDTO> listaPDTO= new ArrayList<PrenotazioneDTO>();
		
		for(int i=0; i<listaPrenotazioni.size();i++){
			PrenotazioneDTO pren= new PrenotazioneDTO();
			
			pren.setIdPrenotazione(listaPrenotazioni.get(i).getIdPrenotazione());
			pren.setEmail(listaPrenotazioni.get(i).getEmail());
			pren.setData(listaPrenotazioni.get(i).getData());
			pren.setN_Persone(listaPrenotazioni.get(i).getN_Persone());
			pren.setPrezzo(listaPrenotazioni.get(i).getPrezzo());
			pren.setCodiceVolo(listaPrenotazioni.get(i).getVolo_Codice());
			
			listaPDTO.add(pren);
		}
		
		return listaPDTO;
	}
	
	public ArrayList<HotelDTO> listaHotelPrenotazione(int codice){
		Query q=em.createNamedQuery("Hotel.trovaHotelInPrenotazione").setParameter("codice", codice);
		List<Hotel_Prenotazione> listaHotel =  (List<Hotel_Prenotazione>) q.getResultList();
		ArrayList<HotelPrenotazioneDTO> listaHPDTO= new ArrayList<HotelPrenotazioneDTO>();
		
		for(int i=0; i<listaHotel.size();i++){
			HotelPrenotazioneDTO hotel= new HotelPrenotazioneDTO();
			
			hotel.setID_Hotel_Prenotazione(listaHotel.get(i).getID_Hotel_Prenotazione()); //tecnicamente inutile
			hotel.setIdHotel(listaHotel.get(i).getHotel_Codice());
			hotel.setIdPrenotazione(listaHotel.get(i).getPrenotazione_IdPrenotazione()); //tecnicamente inutile
			
			listaHPDTO.add(hotel);
		}
		
		ArrayList<HotelDTO> listaHDTO= new ArrayList<HotelDTO>();
		for(int i=0;i<listaHPDTO.size();i++){
			Query k=em.createNamedQuery("Hotel.findProprioAll").setParameter("codice", listaHPDTO.get(i).getIdHotel());
			List<Hotel> listaHotelFinale =  (List<Hotel>) k.getResultList();
			for(int j=0; j<listaHotelFinale.size();j++ ){
				HotelDTO h = new HotelDTO();
				
				h.setNome(listaHotelFinale.get(j).getNome());
				h.setCodice(listaHotelFinale.get(j).getCodice());
				h.setIndirizzo(listaHotelFinale.get(j).getIndirizzo());
				h.setMail(listaHotelFinale.get(j).getMail());
				h.setN_Stelle(listaHotelFinale.get(j).getN_Stelle());
				h.setPrezzo(listaHotelFinale.get(j).getPrezzo());
				h.setStanze_Disponibili(listaHotelFinale.get(j).getStanze_Disponibili());
				h.setTelefono(listaHotelFinale.get(j).getTelefono());
				h.setCitta(listaHotelFinale.get(j).getCitta());
				
				listaHDTO.add(h);
			}
			
		}
		
		return listaHDTO;
		
	}

	public ArrayList<EscursioneDTO> listaEscursioniPrenotazione(int codice){
		Query q=em.createNamedQuery("Escursione.trovaEscursioneInPrenotazione").setParameter("codice", codice);
		List<Escursione_Prenotazione> listaEscursioni =  (List<Escursione_Prenotazione>) q.getResultList();
		ArrayList<EscursionePrenotazioneDTO> listaEPDTO= new ArrayList<EscursionePrenotazioneDTO>();
		
		for(int i=0; i<listaEscursioni.size();i++){
			EscursionePrenotazioneDTO escursione= new EscursionePrenotazioneDTO();
			
			escursione.setID_Escursione_Prenotazione(listaEscursioni.get(i).getID_Escursione_Prenotazione());  //tecnicamente inutile
			escursione.setIdEscursione(listaEscursioni.get(i).getEscursione_Codice());
			escursione.setIdPrenotazione(listaEscursioni.get(i).getPrenotazione_IdPrenotazione());  //tecnicamente inutile
			
			listaEPDTO.add(escursione);
		}
		
		ArrayList<EscursioneDTO> listaEDTO= new ArrayList<EscursioneDTO>();
		for(int i=0;i<listaEPDTO.size();i++){
			Query k=em.createNamedQuery("Escursione.findProprioAll").setParameter("codice", listaEPDTO.get(i).getIdEscursione());
			List<Escursione> listaEscursioniFinale =  (List<Escursione>) k.getResultList();
			for(int j=0; j<listaEscursioniFinale.size();j++ ){
				EscursioneDTO e = new EscursioneDTO();
				
				e.setNome(listaEscursioniFinale.get(j).getNome());
				e.setCodice(listaEscursioniFinale.get(j).getCodice());
				e.setDurata(listaEscursioniFinale.get(j).getDurata());
				e.setLuogoPartenza(listaEscursioniFinale.get(j).getLuogoPartenza());
				e.setPrezzo(listaEscursioniFinale.get(j).getPrezzo());
				e.setStagione(listaEscursioniFinale.get(j).getStagione());
				e.setTipologia(listaEscursioniFinale.get(j).getTipologia());
				
				listaEDTO.add(e);
			}
			
		}
		
		return listaEDTO;
		
	}
	
}
